// { "framework": "Vue"} 

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 487);
/******/ })
/************************************************************************/
/******/ ({

/***/ 1:
/***/ (function(module, exports, __webpack_require__) {

"use strict";
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

(function (define) {
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {

        var forEach = Array.prototype.forEach;
        var hasOwn = Object.prototype.hasOwnProperty;
        var breaker = {};
        var isArray = function isArray(elem) {
            return (typeof elem === "undefined" ? "undefined" : _typeof(elem)) === "object" && elem instanceof Array;
        };
        var isFunction = function isFunction(fn) {
            return typeof fn === "function";
        };

        var // Static reference to slice
        sliceDeferred = [].slice;

        // String to Object flags format cache
        var flagsCache = {};

        // Convert String-formatted flags into Object-formatted ones and store in cache
        function createFlags(flags) {
            var object = flagsCache[flags] = {},
                i,
                length;
            flags = flags.split(/\s+/);
            for (i = 0, length = flags.length; i < length; i++) {
                object[flags[i]] = true;
            }
            return object;
        }

        // Borrowed shamelessly from https://github.com/wookiehangover/underscore.Deferred
        var _each = function _each(obj, iterator, context) {
            var key, i, l;

            if (!obj) {
                return;
            }
            if (forEach && obj.forEach === forEach) {
                obj.forEach(iterator, context);
            } else if (obj.length === +obj.length) {
                for (i = 0, l = obj.length; i < l; i++) {
                    if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) {
                        return;
                    }
                }
            } else {
                for (key in obj) {
                    if (hasOwn.call(obj, key)) {
                        if (iterator.call(context, obj[key], key, obj) === breaker) {
                            return;
                        }
                    }
                }
            }
        };

        var Callbacks = function Callbacks(flags) {

            // Convert flags from String-formatted to Object-formatted
            // (we check in cache first)
            flags = flags ? flagsCache[flags] || createFlags(flags) : {};

            var // Actual callback list
            list = [],

            // Stack of fire calls for repeatable lists
            stack = [],

            // Last fire value (for non-forgettable lists)
            memory,

            // Flag to know if list is currently firing
            firing,

            // First callback to fire (used internally by add and fireWith)
            firingStart,

            // End of the loop when firing
            firingLength,

            // Index of currently firing callback (modified by remove if needed)
            firingIndex,

            // Add one or several callbacks to the list
            _add = function _add(args) {
                var i, length, elem, type, actual;
                for (i = 0, length = args.length; i < length; i++) {
                    elem = args[i];
                    if (isArray(elem)) {
                        // Inspect recursively
                        _add(elem);
                    } else if (isFunction(elem)) {
                        // Add if not in unique mode and callback is not in
                        if (!flags.unique || !self.has(elem)) {
                            list.push(elem);
                        }
                    }
                }
            },

            // Fire callbacks
            fire = function fire(context, args) {
                args = args || [];
                memory = !flags.memory || [context, args];
                firing = true;
                firingIndex = firingStart || 0;
                firingStart = 0;
                firingLength = list.length;
                for (; list && firingIndex < firingLength; firingIndex++) {
                    if (list[firingIndex].apply(context, args) === false && flags.stopOnFalse) {
                        memory = true; // Mark as halted
                        break;
                    }
                }
                firing = false;
                if (list) {
                    if (!flags.once) {
                        if (stack && stack.length) {
                            memory = stack.shift();
                            self.fireWith(memory[0], memory[1]);
                        }
                    } else if (memory === true) {
                        self.disable();
                    } else {
                        list = [];
                    }
                }
            },

            // Actual Callbacks object
            self = {
                // Add a callback or a collection of callbacks to the list
                add: function add() {
                    if (list) {
                        var length = list.length;
                        _add(arguments);
                        // Do we need to add the callbacks to the
                        // current firing batch?
                        if (firing) {
                            firingLength = list.length;
                            // With memory, if we're not firing then
                            // we should call right away, unless previous
                            // firing was halted (stopOnFalse)
                        } else if (memory && memory !== true) {
                            firingStart = length;
                            fire(memory[0], memory[1]);
                        }
                    }
                    return this;
                },
                // Remove a callback from the list
                remove: function remove() {
                    if (list) {
                        var args = arguments,
                            argIndex = 0,
                            argLength = args.length;
                        for (; argIndex < argLength; argIndex++) {
                            for (var i = 0; i < list.length; i++) {
                                if (args[argIndex] === list[i]) {
                                    // Handle firingIndex and firingLength
                                    if (firing) {
                                        if (i <= firingLength) {
                                            firingLength--;
                                            if (i <= firingIndex) {
                                                firingIndex--;
                                            }
                                        }
                                    }
                                    // Remove the element
                                    list.splice(i--, 1);
                                    // If we have some unicity property then
                                    // we only need to do this once
                                    if (flags.unique) {
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    return this;
                },
                // Control if a given callback is in the list
                has: function has(fn) {
                    if (list) {
                        var i = 0,
                            length = list.length;
                        for (; i < length; i++) {
                            if (fn === list[i]) {
                                return true;
                            }
                        }
                    }
                    return false;
                },
                // Remove all callbacks from the list
                empty: function empty() {
                    list = [];
                    return this;
                },
                // Have the list do nothing anymore
                disable: function disable() {
                    list = stack = memory = undefined;
                    return this;
                },
                // Is it disabled?
                disabled: function disabled() {
                    return !list;
                },
                // Lock the list in its current state
                lock: function lock() {
                    stack = undefined;
                    if (!memory || memory === true) {
                        self.disable();
                    }
                    return this;
                },
                // Is it locked?
                locked: function locked() {
                    return !stack;
                },
                // Call all callbacks with the given context and arguments
                fireWith: function fireWith(context, args) {
                    if (stack) {
                        if (firing) {
                            if (!flags.once) {
                                stack.push([context, args]);
                            }
                        } else if (!(flags.once && memory)) {
                            fire(context, args);
                        }
                    }
                    return this;
                },
                // Call all the callbacks with the given arguments
                fire: function fire() {
                    self.fireWith(this, arguments);
                    return this;
                },
                // To know if the callbacks have already been called at least once
                fired: function fired() {
                    return !!memory;
                }
            };

            return self;
        };

        var Deferred = function Deferred(func) {
            var doneList = Callbacks("once memory"),
                failList = Callbacks("once memory"),
                progressList = Callbacks("memory"),
                _state = "pending",
                lists = {
                resolve: doneList,
                reject: failList,
                notify: progressList
            },
                _promise = {
                done: doneList.add,
                fail: failList.add,
                progress: progressList.add,

                state: function state() {
                    return _state;
                },

                // Deprecated
                isResolved: doneList.fired,
                isRejected: failList.fired,

                then: function then(doneCallbacks, failCallbacks, progressCallbacks) {
                    deferred.done(doneCallbacks).fail(failCallbacks).progress(progressCallbacks);
                    return this;
                },
                always: function always() {
                    deferred.done.apply(deferred, arguments).fail.apply(deferred, arguments);
                    return this;
                },
                pipe: function pipe(fnDone, fnFail, fnProgress) {
                    return Deferred(function (newDefer) {
                        _each({
                            done: [fnDone, "resolve"],
                            fail: [fnFail, "reject"],
                            progress: [fnProgress, "notify"]
                        }, function (data, handler) {
                            var fn = data[0],
                                action = data[1],
                                returned;
                            if (isFunction(fn)) {
                                deferred[handler](function () {
                                    returned = fn.apply(this, arguments);
                                    if (returned && isFunction(returned.promise)) {
                                        returned.promise().then(newDefer.resolve, newDefer.reject, newDefer.notify);
                                    } else {
                                        newDefer[action + "With"](this === deferred ? newDefer : this, [returned]);
                                    }
                                });
                            } else {
                                deferred[handler](newDefer[action]);
                            }
                        });
                    }).promise();
                },
                // Get a promise for this deferred
                // If obj is provided, the promise aspect is added to the object
                promise: function promise(obj) {
                    if (!obj) {
                        obj = _promise;
                    } else {
                        for (var key in _promise) {
                            obj[key] = _promise[key];
                        }
                    }
                    return obj;
                }
            },
                deferred = _promise.promise({}),
                key;

            for (key in lists) {
                deferred[key] = lists[key].fire;
                deferred[key + "With"] = lists[key].fireWith;
            }

            // Handle state
            deferred.done(function () {
                _state = "resolved";
            }, failList.disable, progressList.lock).fail(function () {
                _state = "rejected";
            }, doneList.disable, progressList.lock);

            // Call given func if any
            if (func) {
                func.call(deferred, deferred);
            }

            // All done!
            return deferred;
        };

        // Deferred helper
        var when = function when(firstParam) {
            var args = sliceDeferred.call(arguments, 0),
                i = 0,
                length = args.length,
                pValues = new Array(length),
                count = length,
                pCount = length,
                deferred = length <= 1 && firstParam && isFunction(firstParam.promise) ? firstParam : Deferred(),
                promise = deferred.promise();
            function resolveFunc(i) {
                return function (value) {
                    args[i] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
                    if (! --count) {
                        deferred.resolveWith(deferred, args);
                    }
                };
            }
            function progressFunc(i) {
                return function (value) {
                    pValues[i] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
                    deferred.notifyWith(promise, pValues);
                };
            }
            if (length > 1) {
                for (; i < length; i++) {
                    if (args[i] && args[i].promise && isFunction(args[i].promise)) {
                        args[i].promise().then(resolveFunc(i), deferred.reject, progressFunc(i));
                    } else {
                        --count;
                    }
                }
                if (!count) {
                    deferred.resolveWith(deferred, args);
                }
            } else if (deferred !== firstParam) {
                deferred.resolveWith(deferred, length ? [firstParam] : []);
            }
            return promise;
        };

        Deferred.when = when;
        Deferred.Callbacks = Callbacks;

        return Deferred;
    }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // define for AMD if available
})(__webpack_require__(25));

/***/ }),

/***/ 10:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var domModule = weex.requireModule('dom');
domModule.addRule('fontFace', {
  'fontFamily': 'icon',
  'src': "url('https://at.alicdn.com/t/font_565950_jbhufeemmi.ttf')"
});
module.exports = {};

/***/ }),

/***/ 25:
/***/ (function(module, exports) {

module.exports = function() {
	throw new Error("define cannot be used indirect");
};


/***/ }),

/***/ 313:
/***/ (function(module, exports) {

module.exports = {
  "count-down": {
    "flexDirection": "row",
    "height": "36",
    "alignItems": "center",
    "justifyContent": "center"
  },
  "label": {
    "color": "#686868",
    "fontSize": "24"
  },
  "split-dot": {
    "fontSize": "24",
    "color": "#474747",
    "marginTop": 0,
    "marginRight": "5",
    "marginBottom": 0,
    "marginLeft": "5"
  },
  "val": {
    "backgroundColor": "#464553",
    "color": "#ffffff",
    "width": "36",
    "height": "36",
    "textAlign": "center",
    "lineHeight": "36",
    "borderRadius": "4",
    "fontSize": "24"
  }
}

/***/ }),

/***/ 314:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

var secondsFormatter = __webpack_require__(315);
module.exports = {
  props: {
    seconds: { default: 0 },
    label: { default: '距开始' },
    hour: { default: 0 },
    min: { default: 0 },
    sec: { default: 0 }
  },

  data: function data() {
    return {};
  },

  components: {},
  created: function created() {
    var _this = this;

    setInterval(function () {
      if (_this.seconds < 0) {
        _this.hour = _this.min = _this.sec = 0;
        return;
      }
      var timeInfo = secondsFormatter.timeInfo(_this.seconds--);
      _this.hour = timeInfo.hour;
      _this.min = timeInfo.min;
      _this.sec = timeInfo.sec;
      _this.$emit('update:seconds', _this.seconds);
    }, 1000);
  },

  methods: {}
};

/***/ }),

/***/ 315:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var minSeconds = 60;
var hourSeconds = 3600;
module.exports = {
  timeInfo: function timeInfo(seconds) {
    var hours = parseInt(seconds / hourSeconds);
    seconds -= hours * hourSeconds;
    var min = parseInt(seconds / minSeconds);
    seconds -= min * minSeconds;
    return {
      val: {
        hour: hours,
        min: min,
        sec: seconds
      },
      hour: hours >= 10 ? hours : '0' + hours,
      min: min >= 10 ? min : '0' + min,
      sec: seconds >= 10 ? seconds : '0' + seconds
    };
  }
};

/***/ }),

/***/ 316:
/***/ (function(module, exports) {

module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
  return _c('div', {
    staticClass: ["count-down"]
  }, [(_vm.label) ? _c('text', {
    staticClass: ["label"]
  }, [_vm._v(_vm._s(_vm.label) + " ")]) : _vm._e(), _c('text', {
    staticClass: ["val"]
  }, [_vm._v(_vm._s(_vm.hour))]), _c('text', {
    staticClass: ["split-dot"]
  }, [_vm._v(":")]), (_vm.label) ? _c('text', {
    staticClass: ["val"]
  }, [_vm._v(_vm._s(_vm.min))]) : _vm._e(), _c('text', {
    staticClass: ["split-dot"]
  }, [_vm._v(":")]), (_vm.label) ? _c('text', {
    staticClass: ["val"]
  }, [_vm._v(_vm._s(_vm.sec))]) : _vm._e()])
},staticRenderFns: []}
module.exports.render._withStripped = true

/***/ }),

/***/ 321:
/***/ (function(module, exports) {

module.exports = {
  "progress-bar": {
    "backgroundColor": "#ffe0cc",
    "boxShadow": "inset 0px 0px 10 rgba(0, 0, 0, 0.4)",
    "width": "400",
    "paddingTop": 0,
    "paddingRight": 0,
    "paddingBottom": 0,
    "paddingLeft": "20",
    "justifyContent": "center",
    "height": "30",
    "borderRadius": "30",
    "position": "relative",
    "marginBottom": "20"
  },
  "progress-bar-fill": {
    "backgroundColor": "#ffa366",
    "height": "30",
    "justifyContent": "center",
    "paddingTop": 0,
    "paddingRight": 0,
    "paddingBottom": 0,
    "paddingLeft": "20",
    "position": "absolute",
    "borderRadius": "30",
    "top": 0,
    "left": 0,
    "overflow": "hidden"
  },
  "progress-bar-fill-text": {
    "fontSize": "22",
    "color": "#ffffff",
    "width": "300"
  },
  "progress-bar-bg-text": {
    "fontSize": "22",
    "color": "#ff6600"
  }
}

/***/ }),

/***/ 322:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//


module.exports = {
  props: {
    height: { default: 30 },
    width: { default: 400 },
    value: { default: 0 },
    text: { default: '' }
  },

  data: function data() {
    return {};
  },

  components: {},
  created: function created() {},

  methods: {}
};

/***/ }),

/***/ 323:
/***/ (function(module, exports) {

module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
  return _c('div', {
    staticClass: ["progress-bar"],
    style: {
      height: _vm.height + 'px',
      width: _vm.width + 'px'
    }
  }, [(_vm.text) ? _c('text', {
    staticClass: ["progress-bar-bg-text"]
  }, [_vm._v(_vm._s(_vm.text))]) : _vm._e(), _c('div', {
    staticClass: ["progress-bar-fill"],
    style: {
      width: (_vm.width * _vm.value) + 'px'
    }
  }, [(_vm.text) ? _c('text', {
    staticClass: ["progress-bar-fill-text"]
  }, [_vm._v(_vm._s(_vm.text))]) : _vm._e()])])
},staticRenderFns: []}
module.exports.render._withStripped = true

/***/ }),

/***/ 324:
/***/ (function(module, exports, __webpack_require__) {

var __vue_exports__, __vue_options__
var __vue_styles__ = []

/* styles */
__vue_styles__.push(__webpack_require__(313)
)

/* script */
__vue_exports__ = __webpack_require__(314)

/* template */
var __vue_template__ = __webpack_require__(316)
__vue_options__ = __vue_exports__ = __vue_exports__ || {}
if (
  typeof __vue_exports__.default === "object" ||
  typeof __vue_exports__.default === "function"
) {
if (Object.keys(__vue_exports__).some(function (key) { return key !== "default" && key !== "__esModule" })) {console.error("named exports are not supported in *.vue files.")}
__vue_options__ = __vue_exports__ = __vue_exports__.default
}
if (typeof __vue_options__ === "function") {
  __vue_options__ = __vue_options__.options
}
__vue_options__.__file = "/Users/lvling/workspace/米乐购/laxiaoke-app-mz/src/components/time-countdown.vue"
__vue_options__.render = __vue_template__.render
__vue_options__.staticRenderFns = __vue_template__.staticRenderFns
__vue_options__._scopeId = "data-v-8a91a190"
__vue_options__.style = __vue_options__.style || {}
__vue_styles__.forEach(function (module) {
  for (var name in module) {
    __vue_options__.style[name] = module[name]
  }
})
if (typeof __register_static_styles__ === "function") {
  __register_static_styles__(__vue_options__._scopeId, __vue_styles__)
}

module.exports = __vue_exports__


/***/ }),

/***/ 332:
/***/ (function(module, exports, __webpack_require__) {

var __vue_exports__, __vue_options__
var __vue_styles__ = []

/* styles */
__vue_styles__.push(__webpack_require__(321)
)

/* script */
__vue_exports__ = __webpack_require__(322)

/* template */
var __vue_template__ = __webpack_require__(323)
__vue_options__ = __vue_exports__ = __vue_exports__ || {}
if (
  typeof __vue_exports__.default === "object" ||
  typeof __vue_exports__.default === "function"
) {
if (Object.keys(__vue_exports__).some(function (key) { return key !== "default" && key !== "__esModule" })) {console.error("named exports are not supported in *.vue files.")}
__vue_options__ = __vue_exports__ = __vue_exports__.default
}
if (typeof __vue_options__ === "function") {
  __vue_options__ = __vue_options__.options
}
__vue_options__.__file = "/Users/lvling/workspace/米乐购/laxiaoke-app-mz/src/components/progressbar.vue"
__vue_options__.render = __vue_template__.render
__vue_options__.staticRenderFns = __vue_template__.staticRenderFns
__vue_options__._scopeId = "data-v-1f20decf"
__vue_options__.style = __vue_options__.style || {}
__vue_styles__.forEach(function (module) {
  for (var name in module) {
    __vue_options__.style[name] = module[name]
  }
})
if (typeof __register_static_styles__ === "function") {
  __register_static_styles__(__vue_options__._scopeId, __vue_styles__)
}

module.exports = __vue_exports__


/***/ }),

/***/ 396:
/***/ (function(module, exports) {

module.exports = {
  "icon": {
    "fontFamily": "icon"
  },
  "btn": {
    "paddingTop": 0,
    "paddingRight": "10",
    "paddingBottom": 0,
    "paddingLeft": "10",
    "opacity": 1,
    "transitionProperty": "backgroundColor,color",
    "transitionDuration": 300,
    "transitionTimingFunction": "ease",
    "fontSize": "24",
    "textAlign": "center",
    "borderRadius": "6",
    "opacity:active": 0.6
  },
  "@TRANSITION": {
    "btn": {
      "property": "backgroundColor,color",
      "duration": 300,
      "timingFunction": "ease"
    }
  },
  "btn-default": {
    "backgroundColor": "#eeeeee",
    "color": "#474747"
  },
  "btn-primary": {
    "backgroundColor": "#ff6600",
    "color": "#ffffff"
  },
  "btn-success": {
    "backgroundColor": "#5cb85c",
    "color": "#FFFFFF"
  },
  "btn-warning": {
    "backgroundColor": "#FD9F28",
    "color": "#ffffff"
  },
  "btn-large": {
    "height": "90",
    "lineHeight": "90",
    "borderRadius": "90",
    "fontSize": "36",
    "paddingTop": 0,
    "paddingRight": "40",
    "paddingBottom": 0,
    "paddingLeft": "40"
  },
  "btn-md": {
    "height": "60",
    "lineHeight": "60",
    "fontSize": "28",
    "borderRadius": "10",
    "paddingTop": 0,
    "paddingRight": "20",
    "paddingBottom": 0,
    "paddingLeft": "20"
  },
  "btn-md-radius": {
    "borderRadius": "60"
  },
  "btn-disabled": {
    "backgroundColor": "#bbbbbb",
    "color": "#efefef",
    "opacity:active": 1
  },
  "time-countdown-wrapper": {
    "flexDirection": "row",
    "justifyContent": "flex-start",
    "marginBottom": "10"
  },
  "spi-info": {
    "flexDirection": "row",
    "backgroundColor": "#ffffff",
    "marginTop": "10",
    "marginRight": "10",
    "marginBottom": 0,
    "marginLeft": "10",
    "paddingTop": "10",
    "paddingRight": "10",
    "paddingBottom": "10",
    "paddingLeft": "10",
    "borderRadius": "6"
  },
  "spi-title": {
    "position": "relative",
    "marginBottom": "20"
  },
  "spi-title-text": {
    "fontSize": "28",
    "color": "#474747",
    "lineHeight": "32",
    "lines": 3,
    "textOverflow": "ellipsis"
  },
  "spi-title-icon": {
    "width": "32",
    "height": "32",
    "position": "absolute",
    "top": 0,
    "left": 0
  },
  "spi-slogan": {
    "fontSize": "32",
    "color": "#e39334",
    "marginBottom": "20"
  },
  "spi-pic": {
    "width": "250",
    "height": "250"
  },
  "spi-details": {
    "marginLeft": "20",
    "flex": 1,
    "height": "250",
    "justifyContent": "space-between"
  },
  "spi-commission": {
    "color": "#ff6600",
    "fontSize": "26",
    "marginBottom": "20"
  },
  "spi-row": {
    "flexDirection": "row",
    "justifyContent": "space-between",
    "alignItems": "center"
  },
  "spi-price": {
    "fontSize": "36",
    "color": "#ff6600"
  },
  "spi-price-title": {
    "color": "#8c8c8c",
    "fontSize": "26"
  },
  "spi-price-origin": {
    "color": "#8c8c8c",
    "fontSize": "26"
  },
  "spi-price-wrapper": {
    "flexDirection": "row",
    "alignItems": "center",
    "height": "38"
  },
  "sp-item-row": {
    "flexDirection": "row",
    "justifyContent": "space-between",
    "marginBottom": "12"
  },
  "item-title": {
    "paddingTop": "10",
    "paddingRight": "10",
    "paddingBottom": "10",
    "paddingLeft": "10"
  },
  "item-title-text": {
    "fontSize": "28",
    "color": "#474747",
    "lineHeight": "3",
    "lines": 2,
    "textOverflow": "ellipsis"
  },
  "item-title-icon": {
    "width": "32",
    "height": "32",
    "position": "absolute",
    "top": "10",
    "left": "10"
  },
  "sp-item": {
    "backgroundColor": "#ffffff",
    "position": "relative"
  },
  "topbar": {
    "position": "absolute",
    "top": 0,
    "right": 0,
    "paddingTop": "10",
    "paddingRight": "10",
    "paddingBottom": "10",
    "paddingLeft": "10",
    "left": 0,
    "alignItems": "center",
    "justifyContent": "flex-end",
    "justifyItems": "flex-end",
    "flexDirection": "row"
  },
  "topbar-btn": {
    "marginLeft": "10"
  },
  "detail-row": {
    "flexDirection": "row",
    "justifyContent": "space-between",
    "paddingTop": 0,
    "paddingRight": "10",
    "paddingBottom": 0,
    "paddingLeft": "10",
    "marginBottom": "10",
    "alignItems": "flex-end"
  },
  "sales-row": {
    "marginBottom": 0
  },
  "origin-price": {
    "color": "#8c8c8c",
    "fontSize": "24",
    "fontWeight": "100"
  },
  "sales": {
    "fontSize": "24",
    "color": "#8c8c8c"
  },
  "price": {
    "flexDirection": "row",
    "alignItems": "flex-end"
  },
  "price-y": {
    "fontSize": "24",
    "color": "#ff6600",
    "fontWeight": "100"
  },
  "price-val": {
    "color": "#ff6600",
    "fontSize": "32"
  },
  "remain-num": {
    "flexDirection": "row",
    "alignItems": "flex-end"
  },
  "remain-num-title": {
    "color": "#8c8c8c",
    "fontSize": "22"
  },
  "remain-num-value": {
    "color": "#e39334",
    "fontSize": "24"
  }
}

/***/ }),

/***/ 397:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

var urlPath = __webpack_require__(6);
__webpack_require__(10);
var modal = weex.requireModule('modal');
module.exports = {
  components: {
    'progress-bar': __webpack_require__(332),
    'time-countdown': __webpack_require__(324)
  },
  props: {
    itemList: { default: [] },
    column: { default: 2 },
    showDelBtn: { default: false },
    showSelBtn: { default: false }
  },

  data: function data() {
    return {};
  },
  created: function created() {},

  methods: {
    onImageLoad: function onImageLoad(e) {
      modal.alert({ message: JSON.stringify(e) });
    },
    spItemClick: function spItemClick(item) {
      this.$emit('spItemClick', item);
    },
    delClick: function delClick(item) {
      this.$emit('spItemDel', item);
    },
    selClick: function selClick(item) {
      item._selected = !item._selected;
      this.$emit('spItemSel', item, item._selected);
    },
    getPlatformIcon: function getPlatformIcon(item) {
      return urlPath.assets('images/icon/platform/' + item.ecomPlat + '.png');
    }
  }
};

/***/ }),

/***/ 398:
/***/ (function(module, exports) {

module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
  return _c('div', [_vm._l((_vm.itemList), function(item) {
    return [_c('div', {
      key: item.id,
      staticClass: ["spi-info"],
      on: {
        "click": function($event) {
          _vm.spItemClick(item)
        }
      }
    }, [_c('image', {
      staticClass: ["spi-pic"],
      attrs: {
        "src": item.picUrl,
        "resize": "contain"
      }
    }), _c('div', {
      staticClass: ["spi-details"]
    }, [_c('div', {
      staticClass: ["spi-title"]
    }, [_c('image', {
      staticClass: ["spi-title-icon"],
      attrs: {
        "src": _vm.getPlatformIcon(item)
      }
    }), _c('text', {
      staticClass: ["spi-title-text"]
    }, [_vm._v("     " + _vm._s(item.title))])]), (item.remainSeconds > 0) ? _c('div', {
      staticClass: ["time-countdown-wrapper"]
    }, [_c('time-countdown', {
      attrs: {
        "seconds": item.remainSeconds
      },
      on: {
        "update:seconds": function($event) {
          _vm.$set(item, "remainSeconds", $event)
        }
      }
    })], 1) : _vm._e(), _c('progress-bar', {
      attrs: {
        "text": '剩余' + (item.remainNum + '/' + item.totalNum),
        "value": (item.totalNum - item.remainNum) / item.totalNum
      }
    }), _c('div', {
      staticClass: ["spi-row"]
    }, [_c('div', {
      staticClass: ["spi-price-wrapper"]
    }, [_c('text', {
      staticClass: ["spi-price-title"]
    }, [_vm._v("咪乐族人: ")]), _c('text', {
      staticClass: ["spi-price"]
    }, [_vm._v("¥ " + _vm._s(item.price.toFixed(2)))]), _c('text', {
      staticClass: ["spi-price-origin"]
    }, [_vm._v("    " + _vm._s(item.ecomPlatTitle) + "价: ¥ " + _vm._s(item.originPrice.toFixed(2)))])])])], 1)])]
  })], 2)
},staticRenderFns: []}
module.exports.render._withStripped = true

/***/ }),

/***/ 487:
/***/ (function(module, exports, __webpack_require__) {

var __vue_exports__, __vue_options__
var __vue_styles__ = []

/* styles */
__vue_styles__.push(__webpack_require__(396)
)

/* script */
__vue_exports__ = __webpack_require__(397)

/* template */
var __vue_template__ = __webpack_require__(398)
__vue_options__ = __vue_exports__ = __vue_exports__ || {}
if (
  typeof __vue_exports__.default === "object" ||
  typeof __vue_exports__.default === "function"
) {
if (Object.keys(__vue_exports__).some(function (key) { return key !== "default" && key !== "__esModule" })) {console.error("named exports are not supported in *.vue files.")}
__vue_options__ = __vue_exports__ = __vue_exports__.default
}
if (typeof __vue_options__ === "function") {
  __vue_options__ = __vue_options__.options
}
__vue_options__.__file = "/Users/lvling/workspace/米乐购/laxiaoke-app-mz/src/components/sp-item-cell.vue"
__vue_options__.render = __vue_template__.render
__vue_options__.staticRenderFns = __vue_template__.staticRenderFns
__vue_options__._scopeId = "data-v-574c1eb3"
__vue_options__.style = __vue_options__.style || {}
__vue_styles__.forEach(function (module) {
  for (var name in module) {
    __vue_options__.style[name] = module[name]
  }
})
if (typeof __register_static_styles__ === "function") {
  __register_static_styles__(__vue_options__._scopeId, __vue_styles__)
}

module.exports = __vue_exports__
module.exports.el = 'true'
new Vue(module.exports)


/***/ }),

/***/ 5:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = {
  isWeb: function isWeb() {
    return weex.config.env.platform.toUpperCase() === 'WEB';
  },
  isIOS: function isIOS() {
    return weex.config.env.platform.toUpperCase() === 'IOS';
  }
};

/***/ }),

/***/ 6:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var bundleJsService = weex.requireModule('bundleJsService');
var bundleJsServer = 'https://bundlejs.mizugou.com';
var storageKeys = __webpack_require__(9);
var storage = __webpack_require__(8);
var platform = __webpack_require__(5);
if (typeof weex.config.env.debug === 'string') {
  weex.config.env.debug = weex.config.env.debug === 'true';
}

var DEBUG = weex.config.env.debug;

var mode = 'pro';
var assetsBase, pageBase, apiBase;
function setEnv(env) {
  switch (env) {
    case 'pro':
      assetsBase = 'https://imgs.mizugou.com/assets';
      pageBase = 'https://bundlejs.mizugou.com/';
      bundleJsServer = 'https://bundlejs.mizugou.com';
      apiBase = 'https://apix.mizugou.com';
      break;
    case 'my':
      assetsBase = 'http://192.168.31.174/mz-assets';
      if (platform.isWeb()) {
        pageBase = 'http://192.168.31.174:8081/';
      } else {
        pageBase = 'http://192.168.31.174/mz/';
      }
      apiBase = 'http://192.168.31.174:8083/';
      DEBUG = true;
      break;
    case 'phone':
      assetsBase = 'http://192.168.43.135/mz-assets';
      if (platform.isWeb()) {
        pageBase = 'http://192.168.43.135:8081/';
      } else {
        pageBase = 'http://192.168.43.135/mz/';
      }
      apiBase = 'http://192.168.43.135:8083/';
      DEBUG = true;
      break;
  }
}
setEnv(mode);

// config.config().done(cfg => {
//   if((cfg.debug && cfg.devEnv) || weex.config.env.debug) {
//     mode = 'dev'
//     setEnv(mode)
//   }
// })

function wrapVersion(path, flag) {
  if (!flag) {
    return path;
  }
  if (path.indexOf('?') !== -1) {
    path += '&_=' + new Date().getTime();
  } else {
    path += '?_=' + new Date().getTime();
  }
  return path;
}

if (!pageBase.endsWith('/')) {
  pageBase += '/';
}
module.exports = {
  assets: function assets(path, version) {
    var base = assetsBase;
    return wrapVersion(base + '/' + path, version);
  },
  page: function page(path, version, callback) {
    if (platform.isWeb()) {
      path = path.replace('.js', '.html');
    }
    if (typeof version === 'function') {
      callback = version;
      version = null;
    }
    var base = pageBase;
    if (path.startsWith('//')) {
      base = 'http:';
    } else if (path.startsWith('http://') || path.startsWith('https://')) {
      base = '';
    } else if (!DEBUG) {
      if (platform.isWeb()) {
        callback && callback(wrapVersion(pageBase + path, version), path);
        return;
      }
      storage.getItem(storageKeys.BUNDLE_JS_VERSION).done(function (version) {
        var server = DEBUG ? pageBase : bundleJsServer + '/' + version + '/';
        var pathSeg = path.split('?');
        var basePath = pathSeg[0];
        bundleJsService.local({
          remote: server + basePath + '?_=' + new Date().getTime(),
          local: basePath
        }, function (localJs) {
          callback && callback(wrapVersion(localJs + (pathSeg.length > 1 ? '?' + pathSeg[1] : ''), version));
        });
      });
      return;
    }
    callback && callback(wrapVersion(base + path, version), path);
  },
  api: function api(path, version) {
    var base = apiBase;
    return wrapVersion(base + '/' + path, version);
  }
};

/***/ }),

/***/ 8:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var storage = weex.requireModule('storage');
var Deferred = __webpack_require__(1);
module.exports = {
  setItem: function setItem(key, value) {
    var deferred = new Deferred();
    value = JSON.stringify(value);
    storage.setItem(key, value, function (rs) {
      deferred.resolve(rs);
    });
    return deferred.promise();
  },
  getItem: function getItem(key, defaultVal) {
    var deferred = new Deferred();
    storage.getItem(key, function (rs) {
      if (rs.result === 'failed') {
        deferred.resolve(null || defaultVal, rs);
      } else {
        try {
          deferred.resolve(JSON.parse(rs.data), rs);
        } catch (e) {
          deferred.resolve(null || defaultVal, rs);
        }
      }
    });
    return deferred.promise();
  },
  removeItem: function removeItem(key) {
    var deferred = new Deferred();
    storage.removeItem(key, function (rs) {
      deferred.resolve(rs);
    });
    return deferred.promise();
  },
  length: function length() {
    var deferred = new Deferred();
    storage.length(function (rs) {
      deferred.resolve(rs.data, rs);
    });
    return deferred.promise();
  },
  getAllKeys: function getAllKeys(callback) {
    var deferred = new Deferred();
    storage.length(function (rs) {
      deferred.resolve(rs.data, rs);
    });
    return deferred.promise();
  }
};

/***/ }),

/***/ 9:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = {
  LOGIN: 'LOGIN',
  BUNDLE_JS_VERSION: 'BUNDLE_JS_VERSION',
  USER_ITEM_SELECTION: 'USER_ITEM_SELECTION',
  CONFIG: 'CONFIG',
  NAVIGATOR_COUNT: 'NAVIGATOR_COUNT',
  DEBUG: 'DEBUG',
  PHONE_BIND: 'PHONE_BIND'
};

/***/ })

/******/ });